package cmc

import (
	"context"
	"service/api/crm/order"
	model "service/model/crm_base"
	ordermodel "service/model/crm_order"
	hr_cache "service/model/hr_cache"
	"service/model/mod"
	"time"

	gpc "gitee.com/cloudapex/protos/comm/pb"
	gpb "gitee.com/cloudapex/protos/crm_base/pb"
	gpbcrm_order "gitee.com/cloudapex/protos/crm_order/pb"
	gpa "gitee.com/cloudapex/protos/hr_cache/pb"

	"gitee.com/cloudapex/ulern/htp"
	"gitee.com/cloudapex/ulern/util"
	"github.com/gin-gonic/gin"
)

/*
 * 描述: 公海列表
 * 路由: /cmc/openList
 * 方法: GET
 * TODU: 1 入参: 机会来源 需要接口来支持
 * TODU: 2 缺少应答字段: 机会来源(好像有) 来源连接
 *********************************************************************/
type OpenList struct {
	mod.SortFinder // 1:入库时间
	mod.PageFinder

	ProjId    int64 `form:"projId" json:"projId" binding:"omitempty"`       // 项目Id
	Chance    int32 `form:"chance" json:"chance" binding:"omitempty"`       // 机会来源
	Education int32 `form:"education" json:"education" binding:"omitempty"` // 学历类型(前端写死的)

	InBgn   int64 `form:"inBgn" json:"inBgn" binding:"omitempty"`     // 入库时间(int)
	InEnd   int64 `form:"inEnd" json:"inEnd" binding:"omitempty"`     // 入库时间(int)
	BackBgn int64 `form:"backBgn" json:"backBgn" binding:"omitempty"` // 回库时间(int)
	BackEnd int64 `form:"backEnd" json:"backEnd" binding:"omitempty"` // 回库时间(int)

	// 时间条件
	cTimes []*gpc.TimeReq
}
type openRspItem struct {
	Base model.BaseBase    `json:"baseBase"`
	Proj model.BaseProject `json:"baseProject"`
	Tg   model.BaseProTg   `json:"baseProTg"`
}

func (this *OpenList) Handle(c *gin.Context, ctx context.Context) htp.Response {
	user := mod.CurrUser(c)

	// 时间条件
	if resp := this.HandleCondiTimes(c, ctx); resp.Err() != nil {
		return resp
	}

	rsp, err := model.Base.GetPoolList(ctx, &gpb.BasePoolReq{
		Page:    int64(this.PageFinder.Page),
		Count:   int64(this.PageFinder.Pnum),
		DesClum: int64(this.SortFinder.Order),
		IsDes:   int64(this.SortFinder.Orule + 1),
		Type:    1, // 未分配的
		BasePool: &gpb.BasePool{
			BaseBase: &gpb.BaseBase{

				Srank: int64(this.Education),
				//Phone: this.Phone,
			},
			BaseProject: &gpb.BaseProject{
				CId:     user.CId,
				PId:     this.ProjId,
				TimeReq: this.cTimes,
				Logic:   int64(model.EBaseL_Open),
			},
			BaseProTg: &gpb.BaseProTg{
				SId: int64(this.Chance),
			},
		},
	})
	if err != nil {
		return htp.RespModelErr("", err)
	}

	items := []*openRspItem{}
	if err := util.Convert(&items, rsp.BasePool); err != nil {
		return htp.RespConvertErr("", err)
	}

	// 处理项目名称
	if resp := this.HandleProjNames(c, ctx, items); resp.Err() != nil {
		return resp
	}

	return htp.RespOK("", &struct {
		Total int64       `json:"total"`
		List  interface{} `json:"list"`
	}{rsp.Count, items})
}

func (this *OpenList) GetProIdListByTime() {

}

func (this *OpenList) HandleCondiTimes(c *gin.Context, ctx context.Context) htp.Response {
	if this.InBgn != 0 { // 入库
		this.cTimes = append(this.cTimes, &gpc.TimeReq{Tag: 1, Start: this.InBgn, End: this.InEnd})
	}
	if this.BackBgn != 0 { // 回库
		this.cTimes = append(this.cTimes, &gpc.TimeReq{Tag: 2, Start: this.BackBgn, End: this.BackEnd})
	}
	return htp.RespOK("", nil)
}
func (this *OpenList) HandleProjNames(c *gin.Context, ctx context.Context, items []*openRspItem) htp.Response {
	user := mod.CurrUser(c)

	names, err := model.Proj.GetProjIdNames(ctx, user.CId)
	if err != nil {
		return htp.RespModelErr("", err)
	}
	for _, it := range items {
		it.Proj.ProjName = names[it.Proj.PId]
	}
	return htp.RespOK("", nil)
}

/*
 * 描述: 公海领取
 * 路由: /cmc/receive
 * 方法: POST
 *********************************************************************/
type Receive struct {
	CsId     int64  `form:"csId" json:"csId" binding:"required"`         // 客户Id
	ProjName string `form:"projName" json:"projName" binding:"required"` // 项目名称
}

type PoolRes struct {
	Base model.BaseBase    `json:"baseBase"`
	Proj model.BaseProject `json:"baseProject"`
	Tg   model.BaseProTg   `json:"baseProTg"`
}

func (this *Receive) Handle(c *gin.Context, ctx context.Context) htp.Response {
	user := mod.CurrUser(c)

	var bres PoolRes
	rsp1, err := model.Base.SelectPool(ctx, &gpb.BasePoolReq{
		BasePool: &gpb.BasePool{
			BaseBase: &gpb.BaseBase{},
			BaseProject: &gpb.BaseProject{
				Id: uint64(this.CsId),
			},
			BaseProTg: &gpb.BaseProTg{},
		},
	})
	if err != nil {
		htp.RespModelErr("", err)
	}

	if err := util.Convert(&bres, rsp1.BasePool); err != nil {
		return htp.RespConvertErr("", err)
	}

	util.Debug("分配的数据详情%s", rsp1)

	if bres.Proj.StationShow == 0 {
		util.Debug("数据没有可见区间%s")
		return htp.RespErr(1, "", nil)
	}

	//数据是否再 用户的可见区间， 用户是否
	bl := order.IsGet(user.ShowId, bres.Proj.StationShow)
	if !bl {
		util.Debug("可见范围判断失败%s", bl)
		return htp.RespErr(1, "不能领取该数据", nil)
	}

	// 领取添加
	rsp, err := model.Base.GetPool(ctx, &gpb.PoolReq{Id: uint64(this.CsId), UId: user.UId, ShowId: user.ShowId[0]})
	if err != nil {
		return htp.RespModelErr("", err)
	}
	// 添加工作池
	_, err = model.Work.WorkPoolAdd(ctx, &gpb.WorkPool{
		Id:     rsp.BasePool.BaseProject.Id,
		CId:    user.CId,
		BId:    rsp.BasePool.BaseBase.Id,
		PId:    rsp.BasePool.BaseProject.PId,
		PName:  this.ProjName,
		UId:    user.UId,
		UName:  user.Name,
		Phone:  rsp.BasePool.BaseBase.Phone,
		ShowId: mod.SectionMaxLv(user.ShowId),
		Levels: rsp.BasePool.BaseProject.Levels,
		Info:   rsp.BasePool.BaseProject.Info,
		Logic:  rsp.BasePool.BaseProject.Logic,
		At:     time.Now().Unix(),
	})
	if err != nil {
		return htp.RespModelErr("", err)
	}

	return htp.RespOK("", nil)
}

/*
 * 描述: 学员详情
 * 路由: /cmc/stuInfo
 * 方法: POST
 *********************************************************************/
type StuInfo struct {
	CsId    uint64 `form:"csId" json:"csId" binding:"required"`                   // 客户Id
	IsAdmin int64  `form:"isAdmin" json:"isAdmin" binding:"required,min=1,max=2"` // 是否是管理端 1是 2否
	Type    int64  `form:"type" json:"type"`                                      // 查询的数据记录 0查询出所有 1出格登记表数据 2订单数据 3.备注数据 4.拨打记录(沟通记录) 5.数据流转记录(信息变更记录)
}

type StuInfoRes struct {
	ResPoolOutNode    []*PoolOutNodeRes    `json:"poolOutNodeRes"`    // 出格登记表数据
	ResOrderItem      []*ResOrderItem      `json:"resOrderItem"`      // 订单数据
	ResPoolNodeItem   []*ResPoolNodeItem   `json:"resPoolNodeItem"`   // 备注数据
	ResCallRecordItem []*ResCallRecordItem `json:"resCallRecordItem"` // 拨打记录(沟通记录)
	ResPoolLogItem    []*ResPoolLogItem    `json:"resPoolLogItem"`    // 数据流转记录(信息变更记录)

}

func (this *StuInfo) Handle(c *gin.Context, ctx context.Context) htp.Response {
	user := mod.CurrUser(c)
	cid := user.CId
	res := &StuInfoRes{
		//ResPoolOutNode:    resPoolOutNodeList,
		//ResPoolNodeItem:   resPoolNodeList,
		//ResCallRecordItem: resCallRecordItem,
		//ResPoolLogItem:    resPoolLogItem,
	}

	// 出格登记表数据
	if this.Type == 0 || this.Type == 1 {
		resPoolOutNodeList := this.PoollOutList(ctx, cid)
		res.ResPoolOutNode = resPoolOutNodeList
	}
	if this.IsAdmin == 1 && (this.Type == 0 || this.Type == 2) {
		// 订单列表
		resOrderList := this.OrderList(ctx, cid)
		res.ResOrderItem = resOrderList

	}
	// 备注
	if this.Type == 0 || this.Type == 3 {
		resPoolNodeList := this.PoolNodeList(ctx, cid)
		res.ResPoolNodeItem = resPoolNodeList
	}

	//  拨打记录
	if this.Type == 0 || this.Type == 4 {
		resCallRecordItem := this.BaseDialList(ctx, cid)
		res.ResCallRecordItem = resCallRecordItem
	}

	//  数据流转记录
	if this.Type == 0 || this.Type == 5 {
		resPoolLogItem := this.BaseLogList(ctx, cid)
		res.ResPoolLogItem = resPoolLogItem
	}

	return htp.RespOK("", res)
}

/*********************************************方法***************************************************************/
// 出格登记表数据
type PoolOutNodeRes struct {
	Id     int64  `form:"id" json:"id"`         //唯一ID
	BpId   uint64 `form:"bpId" json:"bpId"`     //base_project 机会ID
	OuType int64  `form:"ouType" json:"ouType"` //登记原因 1.客户辱骂 2.客户不需要 3.在别的学校报名了 4.其他
	Node   string `form:"node" json:"node"`     //备注
	UId    int64  `form:"uId" json:"uId"`       //登记坐席
	OperId int64  `form:"operId" json:"operId"` //审核人
	At     int64  `form:"at" json:"at"`         //登记时间

	UName    string `form:"uName" json:"uName"`       //登记坐席名
	OperName string `form:"operName" json:"operName"` //审核人名

}

func (this *StuInfo) PoollOutList(ctx context.Context, cid int64) (items []*PoolOutNodeRes) {
	rsp, err := model.PoolOutNode.GetPoolOutNodeList(ctx, &gpb.PoolOutNodeReq{
		PoolOut: &gpb.PoolOutNode{
			BpId: this.CsId,
		},
		Page:    1,
		Count:   1000,
		StartId: 0,
		DesClum: 1,
		IsDes:   1,
	})
	if err != nil {
		return
	}
	//映射
	if err := util.Convert(&items, rsp.PoolOut); err != nil {
		return
	}
	//  人名赋值
	this.setPoollOutUserList(items, ctx, cid)
	return
}

func (this *StuInfo) setPoollOutUserList(res []*PoolOutNodeRes, ctx context.Context, CId int64) {
	//  获取去重的值
	uidList := this.GetPoollOutUidList(res)
	if uidList == nil || len(uidList) == 0 {
		return
	}
	userListRes, _ := hr_cache.UserCacheServer.UserNameList(ctx, &gpa.UserLoginReqIdsReq{CId: CId, Ids: uidList})
	if userListRes == nil || userListRes.NameList == nil || len(userListRes.NameList) == 0 {
		return
	}
	//  审核人赋值
	for i, _ := range res {
		resf := res[i]
		if userListRes != nil && len(userListRes.NameList) > 0 {

			for _, vf := range userListRes.NameList {
				if resf.UId == vf.Id && vf.Name != "" {
					resf.UName = vf.Name
				}
				if resf.OperId == vf.Id && vf.Name != "" {
					resf.OperName = vf.Name
				}
			}
		}

	}
}
func (this *StuInfo) GetPoollOutUidList(items []*PoolOutNodeRes) (uidList []int64) {
	for _, f := range items {
		bo := false
		if len(uidList) > 0 {
			for _, id := range uidList {
				if id == f.UId {
					bo = true
				}
			}
		}
		if !bo && f.UId > 0 {
			uidList = append(uidList, f.UId)
		}
		//审核人
		bo = false
		if len(uidList) > 0 {
			for _, id := range uidList {
				if id == f.OperId {
					bo = true
				}
			}
		}
		if !bo && f.OperId > 0 {
			uidList = append(uidList, f.OperId)
		}
	}
	return
}

// 订单列表
type ResOrderItem struct {
	OrderId    int64              `form:"orderId" json:"orderId"`       //  订单ID
	CommpId    int64              `form:"commpId" json:"commpId"`       //  公司ID
	Phone      string             `form:"phone" json:"phone"`           //  手机号
	BillNo     string             `form:"billNo" json:"billNo"`         //  订单单号
	BillType   int64              `form:"billType" json:"billType"`     //  单号类型  1 全款 2 尾款 3 定金
	CustomerId int64              `form:"customerId" json:"customerId"` //  客户ID
	PlaceId    int64              `form:"placeId" json:"placeId"`       //  下单人
	UserId     int64              `form:"userId" json:"userId"`         //  成单坐席
	ShowId     uint64             `form:"showId" json:"showId"`         //  所属组织ID
	RoleId     int64              `form:"roleId" json:"roleId"`         //  所属角色ID
	Examine    int64              `form:"examine" json:"examine"`       //  审核类型 1 自动审核 2 手动审核
	TotalPrice int64              `form:"totalPrice" json:"totalPrice"` //  实际支付价格
	OrderType  int64              `form:"orderType" json:"orderType"`   //  订单类型 1 网课  2 学历  3 证书 4 代报名 5其他待定
	Notes      string             `form:"notes" json:"notes"`           //  订单通用备注
	CreatedAt  int64              `form:"createdAt" json:"createdAt"`   //  订单下单时间
	PayAt      int64              `form:"payAt" json:"payAt"`           //  订单支付时间
	Status     int64              `form:"status" json:"status"`         //  订单状态  1 未支付  2 已支付  3 已分配 4 已驳回 5手动取消 6自动取消
	Details    []*CrmOrderInfoRes `form:"details" json:"details"`       //  订单下的网课详情
	PayType    int64              `form:"payType" json:"payType"`       //  支付方式
	TeachId    int64              `form:"teachId" json:"teachId"`       //  班主任ID
	CancelAt   int64              `form:"cancelAt" json:"cancelAt"`     //  订单取消时间
	ReasonAt   int64              `form:"reasonAt" json:"reasonAt"`     //  订单驳回时间
	Reason     string             `form:"reason" json:"reason"`         //  订单驳回原因
	AdminId    int64              `form:"adminId" json:"adminId"`       //  审核人
	DistrId    int64              `form:"distrId" json:"distrId"`       //  分配人
	DistrAt    int64              `form:"distrAt" json:"distrAt"`       //  分配时间

	PlaceName string `form:"placeName" json:"placeName"` //  下单人名称
	ShowName  string `form:"showName" json:"showName"`   //  所属组织名称

}

// 说明：创建网课出参
//*************************************************************
type CrmOrderInfoRes struct {
	InfoId  int64 `form"infoId" json:"infoId"`   //网课ID
	OrderId int64 `form"orderId" json:"orderId"` //订单ID
	//*********************start网课班型信息************************
	ProjectId   int64  `form:"projectId" json:"projectId"`     //  项目ID
	ProjectName string `form:"projectName" json:"projectName"` //  项目名称
	ClassId     int64  `form:"classId" json:"classId"`         //  班型ID
	ClassName   string `form:"className" json:"className"`     //  班型名称
	//*********************start学历信息************************
	SchoolId    int64  `form:"schoolId" json:"schoolId"`       //  学校ID
	SchoolName  string `form:"schoolName" json:"schoolName"`   //  学校名称
	MajorId     int64  `form:"majorId" json:"majorId"`         //  专业ID
	MajorName   string `form:"majorName" json:"majorName"`     //  专业名称
	MStatus     int64  `form:"mStatus" json:"mStatus"`         //  专业分类
	SStatus     int64  `form:"sStatus" json:"sStatus"`         //  学历分类
	SStaName    string `form:"sStaName" json:"sStaName"`       //  学历名称
	StudentName string `form:"studentName" json:"studentName"` //  学员姓名
	IdCard      string `form:"idCard" json:"idCard"`           //  学员身份证号
	Address     string `form:"address" json:"address"`         //  学员户籍地址
	//*********************start证书信息************************
	CertName string `form:"certName" json:"certName"` //  证书名称
	//*********************start报名信息************************
	OAddress string `form:"oAddress" json:"oAddress"` //  取证地址
	//*********************end报名信息**************************
	Price    int64 `form:"price" json:"price"`       //  网课价格
	OStatus  int64 `form:"oStatus" json:"oStatus"`   //  是否退费
	OChange  int64 `form:"oChange" json:"oChange"`   //  是否换课
	OClose   int64 `form:"oClose" json:"oClose"`     //  是否关课
	UpdateAt int64 `form:"updateAt" json:"updateAt"` //  时间
	CloseAt  int64 `form:"closeAt" json:"closeAt"`   //  临时关课时间
}

/******************************详情--订单**************************************************************/
func (this *StuInfo) OrderList(ctx context.Context, cid int64) (items []*ResOrderItem) {
	rsp, err := ordermodel.Order.CrmOrderList(ctx, &gpbcrm_order.CrmOrderListReq{
		CustomerId: this.CsId,
		CommpId:    cid,
		Page:       1,
		Count:      1000,
		Order:      1,
		Orule:      1,
	})
	if err != nil {
		return
	}
	if err := util.Convert(&items, rsp.Data); err != nil {
		return
	}
	//  人名赋值
	this.setOrderUserList(items, ctx, cid)
	//  设置组织架构
	this.setOrderShowList(items, ctx)

	return
}

func (this *StuInfo) setOrderUserList(res []*ResOrderItem, ctx context.Context, CId int64) {
	//  获取去重的值
	uidList := this.GetOrderUidList(res)
	if uidList == nil || len(uidList) == 0 {
		return
	}
	userListRes, _ := hr_cache.UserCacheServer.UserNameList(ctx, &gpa.UserLoginReqIdsReq{CId: CId, Ids: uidList})
	if userListRes == nil || userListRes.NameList == nil || len(userListRes.NameList) == 0 {
		return
	}
	//  审核人赋值
	for i, _ := range res {
		resf := res[i]
		if userListRes != nil && len(userListRes.NameList) > 0 {

			for _, vf := range userListRes.NameList {
				if resf.PlaceId == vf.Id && vf.Name != "" {
					resf.PlaceName = vf.Name
				}

			}
		}

	}
}
func (this *StuInfo) GetOrderUidList(items []*ResOrderItem) (uidList []int64) {
	for _, f := range items {
		bo := false
		if len(uidList) > 0 {
			for _, id := range uidList {
				if id == f.PlaceId {
					bo = true
				}
			}
		}
		if !bo && f.PlaceId > 0 {
			uidList = append(uidList, f.PlaceId)
		}

	}
	return
}

func (this *StuInfo) setOrderShowList(res []*ResOrderItem, ctx context.Context) {

	//  获取去重的值
	s_showids := getShowIdList(res)
	frawCache := &gpa.FullReqUIdsReq{
		Ids: s_showids,
	}
	frawCacheres, _ := hr_cache.FrameWorkCache.GetFraNameByShowIdList(ctx, frawCache)

	for i, _ := range res {
		resf := res[i]
		//组织架构赋值
		if frawCacheres != nil && len(frawCacheres.FullUList) > 0 {

			for _, vf := range frawCacheres.FullUList {

				if resf.ShowId == vf.Id && vf.FullName != "" {
					resf.ShowName = vf.FullName
				}
			}
		}

	}
}

func getShowIdList(res []*ResOrderItem) (s_showids []uint64) {
	for _, v := range res {
		fage := false
		for ssi, _ := range s_showids {
			if v.ShowId == s_showids[ssi] {
				fage = true
				break
			}
		}
		if !fage {
			s_showids = append(s_showids, v.ShowId)
		}
	}
	return
}

/***********************************备注**********************************************/

type ResPoolNodeItem struct {
	UId      int64  `form:"uId" json:"uId"`           //-- 登记坐席
	PId      int64  `form:"pId" json:"pId"`           //项目ID
	Id       uint64 `form:"id" json:"id"`             //唯一ID
	At       int64  `form:"at" json:"at"`             //登记时间
	BId      uint64 `form:"bId" json:"bId"`           //base_base Id
	BpId     uint64 `form:"bpId" json:"bpId"`         //base_project 机会ID (业务员客户的id)
	NodeType int64  `form:"nodeType" json:"nodeType"` //沟通类型 1.正常接通 2.未接通 3.关/停机 4.空号
	Node     string `form:"node" json:"node"`         //备注

	UName string `form:"uName" json:"uName"` //登记坐席名

}

func (this *StuInfo) PoolNodeList(ctx context.Context, cid int64) (items []*ResPoolNodeItem) {
	rsp, err := model.PoolNodeSer.GetPoolNodeList(ctx, &gpb.PoolNodeReq{
		PoolNode: &gpb.PoolNode{BpId: this.CsId},
		Page:     1,
		Count:    1000,
		StartId:  0,
		DesClum:  0,
		IsDes:    0,
		Type:     0,
	})
	if err != nil {
		return
	}
	if err := util.Convert(&items, rsp.PoolNode); err != nil {
		return
	}
	//  人名赋值
	this.setPoolNodeUserList(items, ctx, cid)
	return
}

func (this *StuInfo) setPoolNodeUserList(res []*ResPoolNodeItem, ctx context.Context, CId int64) {
	//  获取去重的值
	uidList := this.GetPoolNodeUidList(res)
	if uidList == nil || len(uidList) == 0 {
		return
	}
	userListRes, _ := hr_cache.UserCacheServer.UserNameList(ctx, &gpa.UserLoginReqIdsReq{CId: CId, Ids: uidList})
	if userListRes == nil || userListRes.NameList == nil || len(userListRes.NameList) == 0 {
		return
	}
	//  审核人赋值
	for i, _ := range res {
		resf := res[i]
		if userListRes != nil && len(userListRes.NameList) > 0 {

			for _, vf := range userListRes.NameList {
				if resf.UId == vf.Id && vf.Name != "" {
					resf.UName = vf.Name
				}

			}
		}

	}
}

func (this *StuInfo) GetPoolNodeUidList(items []*ResPoolNodeItem) (uidList []int64) {
	for _, f := range items {
		bo := false
		if len(uidList) > 0 {
			for _, id := range uidList {
				if id == f.UId {
					bo = true
				}
			}
		}
		if !bo && f.UId > 0 {
			uidList = append(uidList, f.UId)
		}

	}
	return
}

/***********************************拨打记录**********************************************/
type ResCallRecordItem struct {
	Id       uint64 `form:"id" json:"id"`             //  拨打ID
	CId      int64  `form:"cId" json:"cId"`           //  公司id
	ShowId   int64  `form:"showId" json:"showId"`     //  统计ID（网络电话的id【一个长串】）
	Phone    int64  `form:"phone" json:"phone"`       //  目标手机号
	Duration int64  `form:"duration" json:"duration"` //  通话时长(秒)
	WayId    int64  `form:"wayId" json:"wayId"`       //  拨打方式 1.科天云(网络电话) 2.销冠助手 3.TQ
	UId      int64  `form:"uId" json:"uId"`           //  坐席id

	PId     int64  `form:"pId" json:"pId"`         //  项目表 id
	BId     uint64 `form:"bId" json:"bId"`         //  base_base id
	BpId    uint64 `form:"bpId" json:"bpId"`       //  base_pro id（客户id）
	SdId    int64  `form:"sdId" json:"sdId"`       //  staff_dial id
	FileUrl string `form:"fileUrl" json:"fileUrl"` //  录音文件地址
	State   int64  `form:"state" json:"state"`     //  状态： 1 只有通话记录，2 有通话时长， 3 有通话录音
	At      int64  `form:"at" json:"at"`           //  数据入库时间

	UName string `form:"uName" json:"uName"` //  拨打坐席名

}

func (this *StuInfo) BaseDialList(ctx context.Context, cid int64) (items []*ResCallRecordItem) {
	rsp, err := model.BaseDial.GetCallList(ctx, &gpb.CallListReq{
		CallRecord: &gpb.CallRecord{
			BpId: this.CsId,
		},
		Page:    1,
		Count:   1000,
		StartId: 0,
		DesClum: 0,
		IsDes:   0,
		Type:    0,
	})
	if err != nil {
		return
	}
	if err := util.Convert(&items, rsp.CallRecord); err != nil {
		return
	}
	//  人名赋值
	this.setBaseDialUserList(items, ctx, cid)
	return
}

func (this *StuInfo) setBaseDialUserList(res []*ResCallRecordItem, ctx context.Context, CId int64) {
	//  获取去重的值
	uidList := this.GetBaseDialUidList(res)
	if uidList == nil || len(uidList) == 0 {
		return
	}
	userListRes, _ := hr_cache.UserCacheServer.UserNameList(ctx, &gpa.UserLoginReqIdsReq{CId: CId, Ids: uidList})
	if userListRes == nil || userListRes.NameList == nil || len(userListRes.NameList) == 0 {
		return
	}
	//  审核人赋值
	for i, _ := range res {
		resf := res[i]
		if userListRes != nil && len(userListRes.NameList) > 0 {

			for _, vf := range userListRes.NameList {
				if resf.UId == vf.Id && vf.Name != "" {
					resf.UName = vf.Name
				}

			}
		}

	}
}

func (this *StuInfo) GetBaseDialUidList(items []*ResCallRecordItem) (uidList []int64) {
	for _, f := range items {
		bo := false
		if len(uidList) > 0 {
			for _, id := range uidList {
				if id == f.UId {
					bo = true
				}
			}
		}
		if !bo && f.UId > 0 {
			uidList = append(uidList, f.UId)
		}

	}
	return
}

/***********************************信息变更**********************************************/
type ResPoolLogItem struct {
	Id     uint64 `form:"id" json:"id"`         //   自增ID
	CId    int64  `form:"cId" json:"cId"`       //   公司ID
	BId    uint64 `form:"bId" json:"bId"`       //  base_base ID
	BpId   uint64 `form:"bpId" json:"bpId"`     //  base_project ID
	PId    int64  `form:"pId" json:"pId"`       //  project ID  项目ID
	Phone  int64  `form:"phone" json:"phone"`   //   手机号
	UId    int64  `form:"uId" json:"uId"`       //   staff ID     员工ID
	Nodes  string `form:"nodes" json:"nodes"`   //   备注信息
	Levers int64  `form:"levers" json:"levers"` //   日志等级
	At     int64  `form:"at" json:"at"`         //   入库时间
	OperId int64  `form:"operId" json:"operId"` // -- 操作人ID， 0 表示系统自动操作

	UName    string `form:"uName" json:"uName"`       //  拨打坐席名
	OperName string `form:"operName" json:"operName"` // -- 操作人名称， 0 表示系统自动操作

}

func (this *StuInfo) BaseLogList(ctx context.Context, cid int64) (items []*ResPoolLogItem) {
	rsp, err := model.BaseLog.GetPoolLogList(ctx, &gpb.PoolLogListReq{
		PoolLog: &gpb.PoolLog{
			BpId: this.CsId,
		},
		Page:    1,
		Count:   1000,
		StartId: 0,
		DesClum: 0,
		IsDes:   0,
		Type:    0,
	})
	if err != nil {
		return
	}
	if err := util.Convert(&items, rsp.PoolLog); err != nil {
		return
	}
	//  人名赋值
	this.setBaseLogUserList(items, ctx, cid)
	return
}

func (this *StuInfo) setBaseLogUserList(res []*ResPoolLogItem, ctx context.Context, CId int64) {
	//  获取去重的值
	uidList := this.GetBaseLogUidList(res)
	if uidList == nil || len(uidList) == 0 {
		return
	}
	userListRes, _ := hr_cache.UserCacheServer.UserNameList(ctx, &gpa.UserLoginReqIdsReq{CId: CId, Ids: uidList})
	if userListRes == nil || userListRes.NameList == nil || len(userListRes.NameList) == 0 {
		return
	}
	//  审核人赋值
	for i, _ := range res {
		resf := res[i]
		if userListRes != nil && len(userListRes.NameList) > 0 {

			for _, vf := range userListRes.NameList {
				if resf.UId == vf.Id && vf.Name != "" {
					resf.UName = vf.Name
				}
				if resf.OperId == vf.Id && vf.Name != "" {
					resf.OperName = vf.Name
				}
			}
		}
		if resf.OperId == 0 {
			resf.OperName = "系统管理员"
		}

	}
}

func (this *StuInfo) GetBaseLogUidList(items []*ResPoolLogItem) (uidList []int64) {
	for _, f := range items {
		bo := false
		if len(uidList) > 0 {
			for _, id := range uidList {
				if id == f.UId {
					bo = true
				}
			}
		}
		if !bo && f.UId > 0 {
			uidList = append(uidList, f.UId)
		}

		//操作人
		bo = false
		if len(uidList) > 0 {
			for _, id := range uidList {
				if id == f.OperId {
					bo = true
				}
			}
		}
		if !bo && f.OperId > 0 {
			uidList = append(uidList, f.OperId)
		}
	}

	return
}
